package com.szml.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.szml.context.BaseContext;
import com.szml.dto.ProductDTO;
import com.szml.dto.ProductPageDTO;
import com.szml.entity.*;
import com.szml.mapper.ProductDetailsMapper;
import com.szml.mapper.SupplierMapper;
import com.szml.mapper.*;
import com.szml.result.PageResult;
import com.szml.result.Result;
import com.szml.service.OperationRecordService;
import com.szml.service.ProductBasicService;
import com.szml.service.ProductPriceRecordService;
import com.szml.vo.ProductPageVO;
import com.szml.vo.ProductVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import static com.szml.constants.BasicProductStatusConstants.*;

/**
* @author 25650
* @description 针对表【product_basic】的数据库操作Service实现
* @createDate 2024-06-17 15:49:11
*/
@Service
@Slf4j
public class ProductBasicServiceImpl extends ServiceImpl<ProductBasicMapper, ProductBasic>
    implements ProductBasicService {

    @Autowired
    private ProductBasicMapper productBasicMapper;
    @Autowired
    private ProductDetailsMapper productDetailsMapper;
    @Autowired
    private SupplierMapper supplierMapper;
    @Autowired
    private ProductPriceRecordService productPriceRecordService;
    //对操纵记录表进行新增
    @Autowired
    private OperationRecordMapper operationRecordMapper;
    @Autowired
    private OperationRecordService operationRecordService;
    /**
     * 新增商品(对商品基本表、商品详情表、供应商表、价格记录表的新增)
     *
     * @param productDTO
     */
    @Override
    @Transactional
    public void createProduct(ProductDTO productDTO) {

        ProductBasic productBasic = new ProductBasic();
        BeanUtils.copyProperties(productDTO, productBasic);

        //对商品详情表插入
        ProductDetails productDetails = new ProductDetails();
        BeanUtils.copyProperties(productDTO, productDetails);
        //将剩余库存设为初始库存
        productDetails.setRemainingStock(productDTO.getInStock());
        log.info("productDetail{}",productDetails);
        productDetailsMapper.insert(productDetails);
        //设置商品基本信息表的商品详情id
        productBasic.setProductDetailsId(productDetails.getPDetailId());

        //对供应商表插入
        Supplier supplier = new Supplier();
        supplier.setName(productDTO.getSupplier());
        supplier.setTel(productDTO.getTel());
        supplierMapper.insert(supplier);
        //设置商品基本信息表的供应商id
        productBasic.setProductSupplierId(supplier.getSupplierId());

//        //TODO 获取当前用户id
//        Long userid = BaseContext.getLoginVO().getUserId();
//        productBasic.setUserId(userid);
        productBasic.setUserId(0L);
        productBasic.setProductOwnerState(0);//0：已编辑
        productBasic.setProductCheckState(0);//0：未审核
        productBasic.setProductOnlineState(0);//0：未上线
        productBasic.setCreateTime(LocalDateTime.now());
        productBasic.setUpdateTime(LocalDateTime.now());
        productBasicMapper.insert(productBasic);

        List<ProductPriceRecord> prices = productDTO.getPrice();
        if (prices != null && !prices.isEmpty()) {
            prices.forEach(priceRecord -> priceRecord.setProductId(productBasic.getProductId()));
            //向价格表插入n条数据
            productPriceRecordService.saveBatch(prices);
        }
    }

    /**
     * 修改商品信息
     *
     * @param productDTO
     * @return
     */
    @Transactional
    public Result updateProduct(ProductDTO productDTO) {
        /**
         * 先更新数据库，再删除缓存
         * **/

        ProductBasic productBasic = new ProductBasic();
        BeanUtils.copyProperties(productDTO, productBasic);
        //查询修改前的基本信息
        QueryWrapper<ProductBasic> queryWrapper = new QueryWrapper<ProductBasic>().eq("product_id", productDTO.getProductId());
        ProductBasic productBasic1 = productBasicMapper.selectOne(queryWrapper);
        log.info("修改前的{}", productBasic1);
        if (productBasic1.getProductOnlineState()== ONLINE_OK) {
             Result.error("商品未下线");
        }
        if (productBasic1.getProductCheckState()== CHECK_NO) {
            Result.error("商品未审核");
        }
        //对商品详情表修改
        ProductDetails productDetails = new ProductDetails();
        productDetails.setPDetailId(productBasic1.getProductDetailsId());
        BeanUtils.copyProperties(productDTO, productDetails);
        //将剩余库存设为初始库存
        productDetails.setRemainingStock(productDTO.getInStock());
        productDetailsMapper.updateById(productDetails);

        //对供应商表插入
        Supplier supplier = new Supplier();
        supplier.setSupplierId(productBasic1.getProductSupplierId());
        supplier.setName(productDTO.getSupplier());
        supplier.setTel(productDTO.getTel());
        supplierMapper.updateById(supplier);

        //TODO 获取当前用户id
//        Long userid = BaseContext.getLoginVO().getUserId();
//        productBasic.setUserId(userid);
        productBasic.setUserId(0L);
        productBasic.setProductOwnerState(0);   //已编辑
        productBasic.setProductCheckState(0);   //未审核
        productBasic.setProductOnlineState(0);  //未上线
        productBasic.setUpdateTime(LocalDateTime.now());

        productBasicMapper.updateById(productBasic);
        //删除原有的价格数据
        productPriceRecordService.remove(
                Wrappers.
                        <ProductPriceRecord>query().
                        lambda().
                        eq(ProductPriceRecord::getProductId,productDTO.getProductId()));
        //插入新的价格数据
        List<ProductPriceRecord> prices = productDTO.getPrice();
        if (prices != null && !prices.isEmpty()) {
            prices.forEach(priceRecord -> priceRecord.setProductId(productDTO.getProductId()));
            //向价格表插入n条数据
            productPriceRecordService.saveBatch(prices);
        }
        return Result.success();
    }
    /**
     * 商品状态的修改
     * **/

    @Override
    public Result checkproduct(int status, Long id) {
//        if (id.isEmpty())
//        {
//            Result.error("商品id为空");
//        }
//        //将商品id转换成long类型
//        Long productid= null;
//        try {
//             productid = Long.valueOf(id);
//        } catch (NumberFormatException e) {
//            System.out.println(productid + " 不是一个有效的长整型数字");
//        }
        //对状态进行修改
        // 创建UpdateWrapper来指定需要更新的字段
        UpdateWrapper<ProductBasic> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("product_id", id); // 指定条件
        updateWrapper.set("product_check_state", status); // 指定需要更新的字段

        // 调用update方法进行更新
        this.update(updateWrapper);

        //操作记录表新增
        //审核通过
        // 1：审核通过
        //-1：审核驳回
        if (status== CHECK_OK)
        {
            log.info("审核通过已记录");
            wichstatusone(id,OKCHECKER,"text");
        }
        if (status==CHECK_NO)
        {
            wichstatusone(id,NOCHECK,"text");
        }
        return Result.success();
    }
    /**
     * 批量删除商品，（要不要考虑删除，当前商品的所以记录）
     * **/
    @Transactional //保证事件的原子性 确保数据的一致性和完整性
    @Override
    public Result deleteAll(Long[] ids) {
        if (ids.length==0)
        {
            Result.error("请先选择要删除的商品！");
        }
        List<Long> list=new ArrayList<>(Arrays.asList(ids));

        //删除商品详情表
        //删除对于的详细商品信息

        // 首先根据productId数组查询商品基本信息表中的detailId数组
        List<ProductBasic> productBasics = productBasicMapper.selectBatchIds(list);
        // 创建一个集合来存储detailId
        List<Long> detailIds = new ArrayList<>();
        // 遍历商品基本信息表中的记录，将每个记录的detailId添加到detailIds集合中
        for (ProductBasic productBasic : productBasics) {
            detailIds.add(productBasic.getProductDetailsId());
        }

        //同时删除该商品的所有操作记录(先删除)
        operationRecordMapper.deleteBatchIds(list);


        // 调用deleteBatchIds方法进行批量删除

        productBasicMapper.deleteBatchIds(list);

        // 最后删除
        productDetailsMapper.deleteBatchIds(detailIds);

        return Result.success();
    }
    /**
     * 查询所有当前时间，需要上线的商品
     * **/
    @Override
    public List<ProductBasic> findProductsToBeOnline(LocalDateTime now) {
        // 构建查询条件
        QueryWrapper<ProductBasic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("product_online_state", ONLINE_WEI);// 假设pending状态表示商品待上线
        queryWrapper.eq("product_check_state",CHECK_OK);//已审核但是未上线的

        List<ProductBasic> aaa = productBasicMapper.selectList(queryWrapper);
        log.info("基本信息{}",aaa);

        // 构建新的查询条件，根据detail_id查询online_time
        QueryWrapper<ProductDetails>queryWrapperdetails = new QueryWrapper<>();
        queryWrapperdetails.lt("time_on", now); // 上线时间小于当前时间

        // 执行查询，获取所有关联的detail_id
        List<ProductDetails> productsWithPendingStatus = productDetailsMapper.selectList(queryWrapperdetails);


        // 执行查询，获取所有即将上线的商品的detail_id
        List<Long> detailIds = productsWithPendingStatus.stream()
                .map(ProductDetails::getPDetailId)
                .collect(Collectors.toList());
        log.info("定时上线——详情信息id{}",detailIds);
        //查询所有到上线时间的商品基本信息
        queryWrapper.in("product_details_id", detailIds);

        return productBasicMapper.selectList(queryWrapper);
    }

    /**
     * 查询所有当前时间，需要下线的商品
     * **/
    @Override
    public List<ProductBasic> findProductsToBeOffline(LocalDateTime now) {
        // 构建查询条件
        QueryWrapper<ProductBasic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("product_online_state", ONLINE_OK); // 假设pending状态表示商品待上线



        // 构建新的查询条件，根据detail_id查询online_time
        QueryWrapper<ProductDetails> queryWrapperdetail = new QueryWrapper<>();
        queryWrapperdetail.lt("time_off", now); // 上线时间小于当前时间

        // 执行查询，获取所有关联的detail_id
        List<ProductDetails> productsWithPendingStatus = productDetailsMapper.selectList(queryWrapperdetail);
        // 执行查询，获取所有即将上线的商品的detail_id
        List<Long> detailIds = productsWithPendingStatus.stream()
                .map(ProductDetails::getPDetailId)
                .collect(Collectors.toList());

        queryWrapper.in("product_details_id", detailIds);

        return productBasicMapper.selectList(queryWrapper);
    }

    /**
     * 商品上下线（一键上下线）
     * 由于BaseContext里面没有值，暂时先设置默认值
     * **/


    @Transactional //保证事件的原子性 确保数据的一致性和完整性
    @Override
    public Result onlineall(int status, Long[] ids) {
        //前端如果没有选择商品就报错
        if (ids.length==0)
        {
            return Result.error("请先选择商品！");
        }
        //批量修改所选商品的上线状态
        UpdateWrapper<ProductBasic> updateWrapper = new UpdateWrapper<>();
        updateWrapper.in("product_id",  ids); // 在where条件中指定id数组
        updateWrapper.set("product_online_state", status); // 设置需要更新的status值 0：未上线  1：已上线-1：已下线
        // 调用update方法进行更新操作
        this.update(updateWrapper);


        //上线操作
        if (status== ONLINE_OK)
        {
            wichstatus(ids,ONLINE,"text");
        }
        //下线操作
        if (status== ONLINE_NO)
        {
            wichstatus(ids, UNONLINE,"text");
        }

        return Result.success();
    }

    /**
     * 批量新增操作记录表的工具方法
     * **/
    private void wichstatus(Long[] ids,String whichStatus,String remark) {
        //对操作记录表进行新增
        List<OperationRecord> records = new ArrayList<>();
        for (Long productId : ids) {
            OperationRecord record = new OperationRecord();
            record.setProductId(productId);
            record.setStatus(whichStatus); // 设置状态值
            record.setOperateTime(LocalDateTime.now()); // 设置操作时间
            //TODO record.setOperator(BaseContext.getLoginVO().getName()); // 设置操作人
            record.setOperator("admin");
            record.setRemark(remark); // 设置备注
            records.add(record);
        }
      operationRecordService.batchInsert(records);
    }
    private void wichstatusone(Long id,String whichStatus,String remark)
    {
        //对操作记录表进行新增
        List<OperationRecord> records = new ArrayList<>();
        OperationRecord record = new OperationRecord();
        record.setProductId(id);
        record.setStatus(whichStatus); // 设置状态值
        record.setOperateTime(LocalDateTime.now()); // 设置操作时间
        //TODO record.setOperator(BaseContext.getLoginVO().getName()); // 设置操作人
        record.setOperator("admin");
        record.setRemark(remark); // 设置备注
        records.add(record);
        //提交
        operationRecordService.batchInsert(records);
        log.info("提交成功");
    }

    /**
     * 商品条件分页查询
     *
     * @param productPageDTO
     * @return
     */

    @Override
    public PageResult conditionSearch(ProductPageDTO productPageDTO) {

        PageHelper.startPage(productPageDTO.getPage(), productPageDTO.getPageSize());
        // 分页查询
        Page<ProductPageVO> page = productBasicMapper.conditionPage(productPageDTO);
        // 封装返回结果
        return new PageResult(page.getTotal(), page.getResult());
    }

    /**
     * 根据商品id查询（商品基本信息表，商品详情表，价格表，供应商表）
     * @param id
     * @return
     */
    @Override
    public ProductVO getProductById(Long id) {
        /**
         * id不存在返回错误信息
         * **/
        //1.商品信息表
        ProductBasic productBasic = productBasicMapper.selectById(id);
        //为空返回错误信息
        if (productBasic==null)
        {
            return null;
        }
        ProductVO productVO = new ProductVO();
        BeanUtils.copyProperties(productBasic, productVO);
        //2.商品详情表
        ProductDetails productDetail = productDetailsMapper.selectById(productBasic.getProductDetailsId());
        BeanUtils.copyProperties(productDetail,productVO);
        //3.价格表
        QueryWrapper<ProductPriceRecord> queryWrapper = new QueryWrapper<ProductPriceRecord>()
                .eq("product_id",id);
        List<ProductPriceRecord> productPriceRecords = productPriceRecordService.list(queryWrapper);
        productVO.setPrice(productPriceRecords);
        //4.供应商表
        Supplier supplier = supplierMapper.selectById(productBasic.getProductSupplierId());
        productVO.setSupplierName(supplier.getName());
        productVO.setTel(supplier.getTel());
        log.info("productVO:{}",productVO);
        return productVO;
    }


}




